const app = getApp();
import TextDecoder from '../../utils/miniprogram-text-decoder'
const chatApi = require('../../api/chat')

Page({
  data: {
    userId: '',
    messages: [],
    page: 1,
    pageSize: 20,
    hasMore: true,
    isLoading: false,
    inputContent: '',
    scrollIntoView: '',
    currentImageUrl: '',
    isDemo: false, // 将演示模式改为false
    streamingMessageId: null, // 当前正在流式输出的消息ID
    isStreaming: false, // 是否正在进行流式输出
    _scrollThrottleTimer: null
  },

  onLoad: function(options) {
    // 获取用户ID，可以从全局app或本地存储获取
    const userId = app.globalData.userId || wx.getStorageSync('userId') || 'test_user_id';
    this.setData({ userId });
    
    // 初始化加载聊天记录
    this.loadChatMessages();
  },

  onShow() {
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 'consult'
      });
    }
  },

  // 加载聊天消息
  loadChatMessages: function() {
    if (!this.data.hasMore || this.data.isLoading) return;
    
    this.setData({ isLoading: true });
    
    // 测试数据 - 如果实际API不可用，可以展示这些测试数据
    const testMessages = [
      {
        id: '1',
        content: '您好，我是AI医生助手，有什么可以帮您解答的健康问题吗？',
        type: 'text',
        isAI: true,
        time: '09:00'
      },
      {
        id: '2',
        content: '我最近老是感觉头疼，特别是早上起床后比较严重。',
        type: 'text',
        isAI: false,
        time: '09:01'
      },
      {
        id: '3',
        content: '您好，头痛可能由多种原因引起。请问您的头痛是持续性的还是间歇性的？是否伴有其他症状如恶心、呕吐、视力模糊等？',
        type: 'text',
        isAI: true,
        time: '09:02'
      },
      {
        id: '4',
        content: '主要是早上起床后比较严重，大概持续1-2小时，然后会减轻。有时候会感到有点头晕。',
        type: 'text',
        isAI: false,
        time: '09:03'
      },
      {
        id: '5',
        content: '这种情况可能与多种因素有关，例如：\n1. 睡眠质量不佳\n2. 早晨低血糖\n3. 颈椎问题\n4. 轻度高血压\n\n建议您观察一下自己的睡眠姿势和睡眠质量，保持充足的水分摄入，如果症状持续存在或加重，建议及时就医检查。',
        type: 'text',
        isAI: true,
        time: '09:05'
      }
    ];

    // 模拟API请求延迟
    setTimeout(() => {
      // 如果是实际环境，取消下面的测试代码，使用真实API请求
      if (this.data.page === 1) {
        this.setData({
          messages: testMessages,
          hasMore: false,  // 测试数据没有更多了
          isLoading: false
        });
        this.scrollToBottom();
        return;
      }
      
      wx.request({
        url: 'https://your-api.com/api/chat/messages',
        method: 'GET',
        data: {
          userId: this.data.userId,
          page: this.data.page,
          pageSize: this.data.pageSize
        },
        success: (res) => {
          if (res.statusCode === 200) {
            const newMessages = res.data.messages || [];
            
            // 格式化消息时间
            newMessages.forEach(msg => {
              msg.time = this.formatTime(new Date(msg.createdAt));
            });
            
            // 如果是首次加载，直接替换消息列表
            if (this.data.page === 1) {
              this.setData({
                messages: newMessages,
                hasMore: newMessages.length === this.data.pageSize
              });
              
              if (newMessages.length > 0) {
                this.scrollToBottom();
              }
            } else {
              // 如果是加载更多，则添加到消息列表的前面
              this.setData({
                messages: [...newMessages, ...this.data.messages],
                hasMore: newMessages.length === this.data.pageSize
              });
            }
          } else {
            wx.showToast({
              title: '获取消息失败',
              icon: 'none'
            });
          }
        },
        fail: () => {
          wx.showToast({
            title: '网络请求失败',
            icon: 'none'
          });
        },
        complete: () => {
          this.setData({ isLoading: false });
        }
      });
    }, 500);
  },
  
  // 加载更多消息（向上滚动触发）
  loadMoreMessages: function() {
    if (this.data.hasMore) {
      this.setData({ page: this.data.page + 1 });
      this.loadChatMessages();
    }
  },
  
  // 监听输入变化
  onInputChange: function(e) {
    this.setData({
      inputContent: e.detail.value
    });
  },
  
  // 发送消息
  sendMessage: function() {
    const content = this.data.inputContent.trim();
    if (!content || this.data.isStreaming) return;
    
    // 创建新消息对象
    const newMessage = {
      id: Date.now().toString(),
      content: content,
      type: 'text',
      isAI: false,
      time: this.formatTime(new Date()),
      status: 'sending' // 发送状态：sending, sent, failed
    };
    
    // 添加到消息列表并清空输入框
    this.setData({
      messages: [...this.data.messages, newMessage],
      inputContent: ''
    });
    
    // 滚动到底部
    this.scrollToBottom();
    
    // 如果是演示模式，创建一个AI的自动回复
    if (this.data.isDemo) {
      setTimeout(() => {
        // 更新消息状态为已发送
        this.updateMessageStatus(newMessage.id, 'sent');
        
        // 模拟AI回复
        const aiReplies = [
          "我理解您的问题，让我为您解答。",
          "您的情况需要进一步了解，能否提供更多细节？",
          "根据您的描述，这可能与多种因素有关。建议您注意休息，保持良好的生活习惯。",
          "这种情况比较常见，一般不需要过度担心。但如果症状持续加重，建议及时就医。",
          "感谢您的信任。根据临床经验，这种情况通常与生活压力、饮食习惯或睡眠质量有关。"
        ];
        
        const randomReply = aiReplies[Math.floor(Math.random() * aiReplies.length)];
        
        const aiMessage = {
          id: Date.now().toString() + 1,
          content: randomReply,
          type: 'text',
          isAI: true,
          time: this.formatTime(new Date())
        };
        
        this.setData({
          messages: [...this.data.messages, aiMessage]
        });
        
        // 滚动到底部
        this.scrollToBottom();
      }, 1000);
      
      return;
    }
    
    // 更新消息状态为已发送
    this.updateMessageStatus(newMessage.id, 'sent');
    
    // 创建流式输出的AI消息占位
    const aiMessageId = Date.now().toString() + 1;
    const aiMessage = {
      id: aiMessageId,
      content: '', // 初始内容为空
      type: 'text',
      isAI: true,
      time: this.formatTime(new Date()),
      streaming: true // 标记为正在流式输出
    };
    
    this.setData({
      messages: [...this.data.messages, aiMessage],
      streamingMessageId: aiMessageId,
      isStreaming: true
    });
    
    // 滚动到底部
    this.scrollToBottom();
    
    // 开始请求流式输出
    this.startStreamingResponse(content, aiMessageId);
  },
  
  // 处理流式响应
  startStreamingResponse: function(userMessage, aiMessageId) {
    // 使用 API 中的流式响应函数
    const requestTask = chatApi.streamChatWithAI(userMessage, {
      success: (res) => {
        // 请求成功完成
        this.completeStreaming(aiMessageId);
      },
      fail: (error) => {
        // 错误处理
        this.handleStreamingError(aiMessageId);
      }
    });
    
    // 处理分块数据
    requestTask.onChunkReceived(response => {
      if (response && response.data) {
        try {
          // 将二进制数据转换为字符串
          const arrayBuffer = new Uint8Array(response.data);
          let str = new TextDecoder().decode(arrayBuffer);
          
          // 过滤空字符串
          if (str && str.trim().length > 0) {
            // 追加内容到AI消息
            this.appendStreamingContent(aiMessageId, str);
          }
        } catch (e) {
          console.error('处理数据块时出错:', e);
        }
      }
    });
  },

  // 追加流式内容
  appendStreamingContent: function(messageId, chunk) {
    // 查找消息在数组中的索引
    const messages = this.data.messages;
    const index = messages.findIndex(msg => msg.id === messageId);
    
    if (index === -1) return;
    
    // 更新消息内容
    const updatedMessages = [...messages];
    updatedMessages[index].content += chunk;
    
    // 更新显示，使用节流控制滚动频率
    if (!this._scrollThrottleTimer) {
      this.setData({
        messages: updatedMessages
      }, () => {
        // 用节流方式触发滚动
        this._scrollThrottleTimer = setTimeout(() => {
          this._scrollThrottleTimer = null;
          this.smoothScrollToBottom();
        }, 200); // 200ms节流，避免太频繁滚动
      });
    } else {
      // 仅更新内容，不触发滚动
      this.setData({
        messages: updatedMessages
      });
    }
  },
  
  // 平滑滚动到底部，简化版本，避免多重滚动
  smoothScrollToBottom: function() {
    const messages = this.data.messages;
    if (messages.length > 0) {
      this.setData({
        scrollIntoView: 'scroll-bottom'
      });
    }
  },
  
  // 完成流式输出
  completeStreaming: function(messageId) {
    // 查找消息在数组中的索引
    const messages = this.data.messages;
    const index = messages.findIndex(msg => msg.id === messageId);
    
    if (index === -1) return;
    
    // 更新消息，移除streaming标记
    const updatedMessages = [...messages];
    updatedMessages[index].streaming = false;
    
    this.setData({
      messages: updatedMessages,
      streamingMessageId: null,
      isStreaming: false
    });
  },
  
  // 处理流式输出错误
  handleStreamingError: function(messageId) {
    // 查找消息在数组中的索引
    const messages = this.data.messages;
    const index = messages.findIndex(msg => msg.id === messageId);
    
    if (index === -1) return;
    
    // 更新消息，添加错误提示
    const updatedMessages = [...messages];
    if (!updatedMessages[index].content) {
      updatedMessages[index].content = '抱歉，AI回复生成失败，请稍后再试。';
    }
    updatedMessages[index].streaming = false;
    updatedMessages[index].error = true;
    
    this.setData({
      messages: updatedMessages,
      streamingMessageId: null,
      isStreaming: false
    });
    
    wx.showToast({
      title: 'AI回复生成失败',
      icon: 'none'
    });
  },
  
  // 更新消息状态
  updateMessageStatus: function(messageId, status) {
    const messages = this.data.messages.map(msg => {
      if (msg.id === messageId) {
        return { ...msg, status };
      }
      return msg;
    });
    
    this.setData({ messages });
  },
  
  // 选择图片
  chooseImage: function() {
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        const tempFilePath = res.tempFilePaths[0];
        
        // 创建图片消息
        const imageMessage = {
          id: Date.now().toString(),
          content: tempFilePath,
          type: 'image',
          isAI: false,
          time: this.formatTime(new Date()),
          status: 'sending'
        };
        
        // 添加到消息列表
        this.setData({
          messages: [...this.data.messages, imageMessage]
        });
        
        // 滚动到底部
        this.scrollToBottom();
        
        // 如果是演示模式
        if (this.data.isDemo) {
          setTimeout(() => {
            // 更新消息状态为已发送
            this.updateMessageStatus(imageMessage.id, 'sent');
            
            // 模拟AI回复图片信息
            const aiMessage = {
              id: Date.now().toString() + 1,
              content: "我已收到您发送的图片，可以看到图片中的内容。请问有什么需要我解答的吗？",
              type: 'text',
              isAI: true,
              time: this.formatTime(new Date())
            };
            
            this.setData({
              messages: [...this.data.messages, aiMessage]
            });
            
            // 滚动到底部
            this.scrollToBottom();
          }, 1000);
          
          return;
        }
        
        // 正常模式：上传图片到服务器
        wx.uploadFile({
          url: 'https://your-api.com/api/chat/upload',
          filePath: tempFilePath,
          name: 'image',
          formData: {
            userId: this.data.userId
          },
          success: (res) => {
            const response = JSON.parse(res.data);
            if (response.success) {
              // 更新消息内容为服务器返回的图片URL
              this.updateMessageContent(imageMessage.id, response.imageUrl);
              this.updateMessageStatus(imageMessage.id, 'sent');
              
              // 如果有AI回复，添加到消息列表
              if (response.aiReply) {
                const aiMessage = {
                  id: Date.now().toString() + 1,
                  content: response.aiReply,
                  type: 'text',
                  isAI: true,
                  time: this.formatTime(new Date())
                };
                
                this.setData({
                  messages: [...this.data.messages, aiMessage]
                });
                
                // 滚动到底部
                this.scrollToBottom();
              }
            } else {
              this.updateMessageStatus(imageMessage.id, 'failed');
            }
          },
          fail: () => {
            this.updateMessageStatus(imageMessage.id, 'failed');
          }
        });
      }
    });
  },
  
  // 更新消息内容
  updateMessageContent: function(messageId, content) {
    const messages = this.data.messages.map(msg => {
      if (msg.id === messageId) {
        return { ...msg, content };
      }
      return msg;
    });
    
    this.setData({ messages });
  },
  
  // 预览图片
  previewImage: function(e) {
    const src = e.currentTarget.dataset.src;
    const imageList = this.data.messages
      .filter(msg => msg.type === 'image')
      .map(msg => msg.content);
    
    wx.previewImage({
      current: src,
      urls: imageList
    });
  },
  
  // 滚动到底部 - 用于非流式内容的常规滚动
  scrollToBottom: function() {
    const messages = this.data.messages;
    if (messages.length > 0) {
      const lastMessageId = messages[messages.length - 1].id;
      this.setData({
        scrollIntoView: 'msg-' + lastMessageId
      });
    }
  },
  
  // 格式化时间
  formatTime: function(date) {
    const hours = date.getHours();
    const minutes = date.getMinutes();
    return [hours, minutes].map(this.formatNumber).join(':');
  },
  
  formatNumber: function(n) {
    n = n.toString();
    return n[1] ? n : '0' + n;
  }
}); 